home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 2 / Atari Mega Archive CD - Volume 2.iso / linux / tools / gtar10.lha / extract.c < prev    next >
C/C++ Source or Header  |  1992-09-09  |  21KB  |  790 lines
  1. /* Extract files from a tar archive.
  2.    Copyright (C) 1988 Free Software Foundation
  3.  
  4. This file is part of GNU Tar.
  5.  
  6. GNU Tar is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GNU Tar is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU Tar; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. /*
  21.  * Extract files from a tar archive.
  22.  *
  23.  * Written 19 Nov 1985 by John Gilmore, ihnp4!hoptoad!gnu.
  24.  *
  25.  * @(#) extract.c 1.32 87/11/11 - gnu
  26.  */
  27.  
  28. #include <stdio.h>
  29. #include <errno.h>
  30. #include <sys/types.h>
  31. #include <sys/stat.h>
  32.  
  33. #ifdef BSD42
  34. #include <sys/file.h>
  35. #endif
  36.  
  37. #ifdef USG
  38. #include <fcntl.h>
  39. #endif
  40.  
  41. #ifdef    MSDOS
  42. #include <fcntl.h>
  43. #endif    /* MSDOS */
  44.  
  45. /*
  46.  * Some people don't have a #define for these.
  47.  */
  48. #ifndef    O_BINARY
  49. #define    O_BINARY    0
  50. #endif
  51. #ifndef O_NDELAY
  52. #define    O_NDELAY    0
  53. #endif
  54.  
  55. #ifdef NO_OPEN3
  56. /* We need the #define's even though we don't use them. */
  57. #include "open3.h"
  58. #endif
  59.  
  60. #ifdef EMUL_OPEN3
  61. /* Simulated 3-argument open for systems that don't have it */
  62. #include "open3.h"
  63. #endif
  64.  
  65. #ifdef amigados
  66. static inline int mknod (char *nam, dev_t maj, dev_t min) 
  67. { extern int errno; errno = EIO; return -1; }
  68. #endif
  69.  
  70. extern int errno;            /* From libc.a */
  71. extern time_t time();            /* From libc.a */
  72. extern char *index();            /* From libc.a or port.c */
  73.  
  74. #include "tar.h"
  75. #include "port.h"
  76.  
  77. extern FILE *msg_file;
  78.  
  79. extern union record *head;        /* Points to current tape header */
  80. extern struct stat hstat;        /* Stat struct corresponding */
  81. extern int head_standard;        /* Tape header is in ANSI format */
  82.  
  83. extern char *save_name;
  84. extern long save_totsize;
  85. extern long save_sizeleft;
  86.  
  87. extern void print_header();
  88. extern void skip_file();
  89. extern void skip_extended_headers();
  90. extern void pr_mkdir();
  91.  
  92. int make_dirs();            /* Makes required directories */
  93.  
  94. static time_t now = 0;            /* Current time */
  95. static we_are_root = 0;            /* True if our effective uid == 0 */
  96. static int notumask = ~0;        /* Masks out bits user doesn't want */
  97.  
  98. /*
  99.  * "Scratch" space to store the information about a sparse file before
  100.  * writing the info into the header or extended header
  101.  */
  102. /*struct sp_array    *sparsearray;*/
  103.  
  104. /* number of elts storable in the sparsearray */
  105. /*int    sp_array_size = 10;*/
  106.  
  107. /*
  108.  * Set up to extract files.
  109.  */
  110. extr_init()
  111. {
  112.     int ourmask;
  113.  
  114.     now = time((time_t *)0);
  115.     if (geteuid() == 0)
  116.         we_are_root = 1;
  117.  
  118.     /*
  119.      * We need to know our umask.  But if f_use_protection is set,
  120.      * leave our kernel umask at 0, and our "notumask" at ~0.
  121.      */
  122.     ourmask = umask(0);        /* Read it */
  123.     if (!f_use_protection) {
  124.         (void) umask (ourmask);    /* Set it back how it was */
  125.         notumask = ~ourmask;    /* Make umask override permissions */
  126.     }
  127. }
  128.  
  129.  
  130. /*
  131.  * Extract a file from the archive.
  132.  */
  133. void
  134. extract_archive()
  135. {
  136.     register char *data;
  137.     int fd, check, namelen, written, openflag;
  138.     long size;
  139.     time_t acc_upd_times[2];
  140.     register int skipcrud;
  141.     register int i;
  142.     int sparse_ind = 0;
  143.     union record *exhdr;    
  144.     int end_nulls;
  145.     
  146.     saverec(&head);            /* Make sure it sticks around */
  147.     userec(head);            /* And go past it in the archive */
  148.     decode_header(head, &hstat, &head_standard, 1);    /* Snarf fields */
  149.  
  150.     if(f_confirm && !confirm("extract",head->header.name)) {
  151.         if (head->header.isextended)
  152.             skip_extended_headers();
  153.         skip_file((long)hstat.st_size);
  154.         saverec((union record **)0);
  155.         return;
  156.     }
  157.  
  158.     /* Print the record from 'head' and 'hstat' */
  159.     if (f_verbose)
  160.         print_header();
  161.  
  162.     /*
  163.      * Check for fully specified pathnames and other atrocities.
  164.      *
  165.      * Note, we can't just make a pointer to the new file name,
  166.      * since saverec() might move the header and adjust "head".
  167.      * We have to start from "head" every time we want to touch
  168.      * the header record.
  169.      */
  170.     skipcrud = 0;
  171.     while (!f_absolute_paths && '/' == head->header.name[skipcrud]) {
  172.         static int warned_once = 0;
  173.  
  174.         skipcrud++;    /* Force relative path */
  175.         if (!warned_once++) {
  176.             msg("Removing leading / from absolute path names in the archive.");
  177.         }
  178.     }
  179.  
  180.     switch (head->header.linkflag) {
  181.  
  182.     default:
  183.         msg("Unknown file type '%c' for %s, extracted as normal file",
  184.             head->header.linkflag, skipcrud+head->header.name);
  185.         /* FALL THRU */
  186.  
  187.     /* 
  188.      * JK - What we want to do if the file is sparse is loop through
  189.      * the array of sparse structures in the header and read in
  190.      * and translate the character strings representing  1) the offset
  191.      * at which to write and 2) how many bytes to write into numbers,
  192.      * which we store into the scratch array, "sparsearray".  This
  193.      * array makes our life easier the same way it did in creating
  194.      * the tar file that had to deal with a sparse file.
  195.      *
  196.      * After we read in the first five (at most) sparse structures,
  197.      * we check to see if the file has an extended header, i.e., 
  198.      * if more sparse structures are needed to describe the contents
  199.      * of the new file.  If so, we read in the extended headers
  200.      * and continue to store their contents into the sparsearray.
  201.      */
  202.     case LF_SPARSE:
  203.         sp_array_size = 10;
  204.         sparsearray = (struct sp_array *) malloc(sp_array_size * sizeof(struct sp_array));
  205.         for (i = 0; i < SPARSE_IN_HDR; i++) {
  206.             sparsearray[i].offset = 
  207.                 from_oct(1+12, head->header.sp[i].offset);
  208.             sparsearray[i].numbytes = 
  209.                 from_oct(1+12, head->header.sp[i].numbytes);
  210.             if (!sparsearray[i].numbytes)
  211.                 break;
  212.         }
  213.         
  214. /*        end_nulls = from_oct(1+12, head->header.ending_blanks);*/
  215.         
  216.         if (head->header.isextended) {
  217.             /* read in the list of extended headers
  218.                and translate them into the sparsearray 
  219.                as before */
  220.  
  221.             /* static */ int ind = SPARSE_IN_HDR;
  222.             
  223.             for (;;) {
  224.                 
  225.                 exhdr = findrec();
  226.                 for (i = 0; i < SPARSE_EXT_HDR; i++) {
  227.                     
  228.                     if (i+ind > sp_array_size-1) {
  229.                     /*
  230.                      * realloc the scratch area
  231.                      * since we've run out of room --
  232.                       */
  233.                         sparsearray = (struct sp_array *) 
  234.                                 realloc(sparsearray,
  235.                                  2 * sp_array_size * (sizeof(struct sp_array)));
  236.                         sp_array_size *= 2;
  237.                     }
  238.                     if (!exhdr->ext_hdr.sp[i].numbytes)
  239.                         break;
  240.                     sparsearray[i+ind].offset = 
  241.                         from_oct(1+12, exhdr->ext_hdr.sp[i].offset);
  242.                     sparsearray[i+ind].numbytes = 
  243.                         from_oct(1+12, exhdr->ext_hdr.sp[i].numbytes);
  244.                 }
  245.                 if (!exhdr->ext_hdr.isextended) 
  246.                     break;
  247.                 else {
  248.                     ind += SPARSE_EXT_HDR;
  249.                     userec(exhdr);
  250.                 }
  251.             }
  252.             userec(exhdr);
  253.         }
  254.         
  255.         /* FALL THRU */
  256.     case LF_OLDNORMAL:
  257.     case LF_NORMAL:
  258.     case LF_CONTIG:
  259.         /*
  260.          * Appears to be a file.
  261.          * See if it's really a directory.
  262.          */
  263.         namelen = strlen(skipcrud+head->header.name)-1;
  264.         if (head->header.name[skipcrud+namelen] == '/')
  265.             goto really_dir;
  266.  
  267.         /* FIXME, deal with protection issues */
  268.     again_file:
  269.         openflag = (f_keep?
  270.             O_BINARY|O_NDELAY|O_WRONLY|O_CREAT|O_EXCL:
  271.             O_BINARY|O_NDELAY|O_WRONLY|O_CREAT|O_TRUNC)
  272.             | ((head->header.linkflag == LF_SPARSE) ? 0 : O_APPEND);            
  273.             /*
  274.              * JK - The last | is a kludge to solve the problem
  275.              * the O_APPEND flag  causes with files we are
  276.              * trying to make sparse:  when a file is opened
  277.              * with O_APPEND, it writes  to the last place
  278.              * that something was written, thereby ignoring
  279.              * any lseeks that we have done.  We add this
  280.              * extra condition to make it able to lseek when
  281.              * a file is sparse, i.e., we don't open the new
  282.              * file with this flag.  (Grump -- this bug caused
  283.              * me to waste a good deal of time, I might add)
  284.                */
  285.  
  286.         if(f_exstdout) {
  287.             fd = 1;
  288.             goto extract_file;
  289.         }
  290. #ifdef O_CTG
  291.         /*
  292.          * Contiguous files (on the Masscomp) have to specify
  293.          * the size in the open call that creates them.
  294.          */
  295.         if (head->header.linkflag == LF_CONTIG)
  296.             fd = open(skipcrud+head->header.name, openflag | O_CTG,
  297.                 hstat.st_mode, hstat.st_size);
  298.         else
  299. #endif
  300.         {
  301.             extern int f_max_namelen;
  302. #ifdef NO_OPEN3
  303.             /*
  304.              * On raw V7 we won't let them specify -k (f_keep), bu